(function () {
  if (!window.cet || !window.cet.microservices || !window.cet.microservices.apiready) {
    window.cet = window.cet || {};
    cet.microservices = cet.microservices || {};

    let apiready = new Promise(function (resolve, reject) {
      var scriptElement = document.createElement("script");
      scriptElement.addEventListener('load', resolve);
      scriptElement.addEventListener('error', reject);
      var origin = document.currentScript.src.split('/', 3).join('/');
      scriptElement.src = origin + "/provider/ApiProvider.js?8dc3063ff20c100";
      document.head.appendChild(scriptElement);
    });
    cet.microservices.apiready = apiready;
  }
  let selfUrl = document.currentScript.src;
  cet.microservices.apiready.then(() => {
    cet.microservices.api.system.addService(selfUrl);
  });
})();
window.cet = window.cet || {}
window.cet.microservices = window.cet.microservices || {}

cet.microservices.walletapi = (function () {

    const settings = {
        apiUrl: "/walletapi"
    }

    const buildQueryFromPayload = function (payload) {

        if (payload && typeof payload === 'object') {

            var str = []

            for (var p in payload) {
                if (payload.hasOwnProperty(p)) {
                    if (Array.isArray(payload[p])) {
                        for (var i = 0; i < payload[p].length; i++) {
                            str.push(encodeURIComponent(p) + "=" + encodeURIComponent(payload[p][i]))
                        }
                    } else {
                        str.push(encodeURIComponent(p) + "=" + encodeURIComponent(payload[p]))
                    }
                }
            }

            return str.length > 0 ? '?' + str.join('&') : ''
        }

        return ''
    }

    const validateRequest = function (request, relevantParameters) {
        if (!request) {
            return 'request data is missing'
        }

        for (var i = 0; i < relevantParameters.length; i++) {
            var param = relevantParameters[i]
            var paramParts = param.split('.')

            var subRequest = request

            if (paramParts.length > 1) {
                for (var p = 0; p < paramParts.length - 1; p++) {
                    subRequest = subRequest && subRequest[paramParts[p]]
                    param = paramParts[p + 1]
                }
            }

            if (!subRequest || !subRequest.hasOwnProperty(param)) {
                return relevantParameters[i] + ' is missing'
            } else {
                var error = validateParameter(relevantParameters[i], subRequest[param])

                if (error) {
                    return error
                }
            }
        }

        return ''
    }

    const validateParameter = function (pName, pValue) {
        if ((typeof pValue === 'string' && pValue.trim().length === 0) ||
            (Array.isArray(pValue) && pValue.length === 0)) {
            return pName + ' cannot be empty'
        }
        return ''
    }

    const processRequest = (request) => {
        var promise = new Promise(function (resolve, reject) {
            var validationErrorMsg = request.validationParams ? validateRequest(request.data, request.validationParams) : ''
            if (validationErrorMsg) {                
                reject({
                    'name': 'ProviderValidationError',
                    'message': validationErrorMsg
                });
            }
            else {
                cet.microservices.apiready.then(async () => {
                    try {
                        var result = null;

                        if (request.type === 'get') {
                            result = await cetms.safe.get(request.URL + buildQueryFromPayload(request.data));
                        } else if (request.type === 'post') {
                            result = await cetms.safe.post(request.URL, request.data);
                        }

                        resolve(result);
                    } catch (error) {
                        reject(error);
                    }
                }).catch(error => {
                    reject(error);
                });
            }
        })

        return promise
    }

    const addLedger = (data) => {

        return processRequest({
            type: 'post',
            URL: settings.apiUrl + '/add/ledger',
            data: data,
            validationParams: ["UserID", "ApplicationID", "WalletItemCode", "Amount", "Context","Timestamp"]
        })
    }

    const getWallet = (data) => {

        return processRequest({
            type: 'post',
            URL: settings.apiUrl + '/wallet',
            data: data,
            validationParams: ["UserID","ApplicationID"]
        })
    }

    const getLedger = (data) => {

        return processRequest({
            type: 'get',
            URL: settings.apiUrl + '/get/ledger',
            data: data,
            validationParams: ["id", "appid"]
        })
    }

    return {

        wallet: {
            get: getWallet
        },

        ledger: {
            add: addLedger,
            get: getLedger
        },

        ver: "1.2"
    }

})()